"""
模板数据管理 API
按照 FastAPI 标准流程：schemas + crud + models
"""
from typing import Optional
from fastapi import APIRouter, Depends, HTTPException, Query
from sqlalchemy.ext.asyncio import AsyncSession

from core.database import get_db
from crud import template_data as crud_template_data
from crud import template as crud_template
from crud import patient as crud_patient
from schemas.template_data import (
    TemplateDataCreate,
    TemplateDataUpdate,
    TemplateDataResponse,
    TemplateDataWithDetailResponse
)
from api.deps import get_current_active_doctor
from models.doctor import Doctor

router = APIRouter()


@router.get("/check-duplicate")
async def check_template_duplicate(
    template_id: int = Query(..., description="模板ID"),
    medical_record_id: Optional[int] = Query(None, description="病历ID（可选）"),
    db: AsyncSession = Depends(get_db),
    current_doctor: Doctor = Depends(get_current_active_doctor),
):
    """
    检查同一病例下是否已存在相同模板
    用于前端在开始填写前进行校验
    
    Args:
        template_id: 模板ID
        medical_record_id: 病历ID（可选，如果没有则返回可以创建）
        
    Returns:
        exists: 是否已存在
        template_name: 模板名称（如果存在）
    """
    try:
        # 如果没有 medical_record_id，直接返回可以创建
        if not medical_record_id:
            return {
                "message": "可以创建",
                "data": {
                    "exists": False
                },
                "code": 0
            }
        
        # 检查是否已存在
        existing_data = await crud_template_data.check_duplicate(
            db,
            template_id=template_id,
            medical_record_id=medical_record_id
        )
        
        if existing_data:
            # 获取模板名称
            template = await crud_template.get(db, id=template_id)
            template_name = template.name if template else "未知量表"
            
            return {
                "message": "该病例下已存在此量表",
                "data": {
                    "exists": True,
                    "template_name": template_name
                },
                "code": 0
            }
        else:
            return {
                "message": "可以创建",
                "data": {
                    "exists": False
                },
                "code": 0
            }
        
    except Exception as e:
        return {
            "message": f"服务器错误: {str(e)}",
            "code": 1
        }


@router.post("/save")
async def save_template_data(
    data_in: TemplateDataCreate,
    db: AsyncSession = Depends(get_db),
    current_doctor: Doctor = Depends(get_current_active_doctor),
):
    """
    保存模板数据
    前端传入：模板ID、模板版本号、患者ID、病历ID（可选）、填写数据（JSON）
    医生ID可选，如果不传则从患者表中获取
    
    流程：
    1. 验证模板是否存在
    2. 验证患者是否存在
    3. 如果没有传 doctor_id，从患者表获取
    4. 获取冗余字段（模板名称、患者姓名）
    5. 保存到数据库
    """
    try:
        # 1. 验证模板是否存在
        template = await crud_template.get(db, id=data_in.template_id)
        if not template:
            return {
                "message": "模板不存在",
                "code": 1
            }
        
        # 2. 验证患者是否存在，并获取医生ID
        patient = await crud_patient.get(db, id=data_in.patient_id)
        if not patient:
            return {
                "message": "患者不存在",
                "code": 1
            }
        
        # 3. 如果前端没有传 doctor_id，从患者表中获取
        doctor_id = data_in.doctor_id
        if doctor_id is None:
            doctor_id = patient.doctor_id
            if doctor_id is None:
                return {
                    "message": "患者未关联医生，无法保存",
                    "code": 1
                }
        
        # 4. 验证医生ID是否与当前登录医生一致（安全检查）
        if doctor_id != current_doctor.id:
            return {
                "message": "医生ID不匹配",
                "code": 1
            }
        
        # 5. 更新 data_in 的 doctor_id（用于保存）
        data_in.doctor_id = doctor_id
        
        # 6. 创建模板数据（带冗余字段）
        template_data = await crud_template_data.create_with_relations(
            db,
            obj_in=data_in,
            template_name=template.name,
            patient_name=patient.name
        )
        
        await db.commit()
        await db.refresh(template_data)
        
        # 7. 返回结果
        response_data = TemplateDataResponse.model_validate(template_data)
        
        return {
            "message": "保存模板数据成功",
            "data": response_data.to_flask_format(),
            "code": 0
        }
        
    except Exception as e:
        await db.rollback()
        return {
            "message": f"服务器错误: {str(e)}",
            "code": 1
        }






# @router.get("/patient/{patient_id}")
# async def get_template_data_by_patient(
#     patient_id: int,
#     skip: int = 0,
#     limit: int = 100,
#     db: AsyncSession = Depends(get_db),
#     current_doctor: Doctor = Depends(get_current_active_doctor),
# ):
#     """
#     根据患者ID查询模板数据列表
#     """
#     try:
#         # 验证患者是否存在
#         patient = await crud_patient.get(db, id=patient_id)
#         if not patient:
#             return {
#                 "message": "患者不存在",
#                 "code": 1
#             }
#        
#         # 查询模板数据列表
#         template_data_list = await crud_template_data.get_by_patient(
#             db,
#             patient_id=patient_id,
#             skip=skip,
#             limit=limit
#         )
#        
#         # 序列化结果
#         result_data = [
#             TemplateDataResponse.model_validate(td).to_flask_format()
#             for td in template_data_list
#         ]
#        
#         return {
#             "message": "查询成功",
#             "data": result_data,
#             "code": 0
#         }
#        
#     except Exception as e:
#         return {
#             "message": f"服务器错误: {str(e)}",
#             "code": 1
#         }


@router.get("/medical-record/{medical_record_id}")
async def get_template_data_by_medical_record(
    medical_record_id: int,
    skip: int = 0,
    limit: int = 100,
    db: AsyncSession = Depends(get_db),
    current_doctor: Doctor = Depends(get_current_active_doctor),
):
    """
    根据病历ID查询模板数据列表
    """
    try:
        # 查询模板数据列表
        template_data_list = await crud_template_data.get_by_medical_record(
            db,
            medical_record_id=medical_record_id,
            skip=skip,
            limit=limit
        )
        
        # 序列化结果
        result_data = [
            TemplateDataResponse.model_validate(td).to_flask_format()
            for td in template_data_list
        ]
        
        return {
            "message": "查询成功",
            "data": result_data,
            "code": 0
        }
        
    except Exception as e:
        return {
            "message": f"服务器错误: {str(e)}",
            "code": 1
        }


@router.get("/{template_data_id}")
async def get_template_data_by_id(
    template_data_id: int,
    db: AsyncSession = Depends(get_db),
    current_doctor: Doctor = Depends(get_current_active_doctor),
):
    """
    根据ID获取模板数据详情
    同时返回对应的模板结构信息
    """
    try:
        # 1. 查询模板数据
        template_data = await crud_template_data.get(db, id=template_data_id)
        
        if not template_data:
            return {
                "message": "模板数据不存在",
                "code": 1
            }
        
        # 2. 查询对应的模板信息
        template = await crud_template.get(db, id=template_data.template_id)
        template_detail = None
        
        if template:
            # 获取模板版本历史
            version_history = template.version_history
            current_version = template_data.template_version
            target_structure = None
            
            if isinstance(version_history, list):
                for v in version_history:
                    if isinstance(v, dict) and v.get('version') == current_version:
                        target_structure = v
                        break
            elif isinstance(version_history, dict):
                # 假设 key 是版本号字符串
                target_structure = version_history.get(str(current_version))
            
            # 如果没找到对应版本，尝试返回整个 version_history 或者返回最新
            # 这里我们优先返回找到的特定版本结构，如果没有找到，则返回整个历史供前端处理
            template_detail = target_structure if target_structure else version_history

        # 3. 构造响应
        response_data = TemplateDataWithDetailResponse.model_validate(template_data)
        response_data.template_detail = template_detail
        
        return {
            "message": "查询成功",
            "data": response_data.to_flask_format_with_detail(),
            "code": 0
        }
        
    except Exception as e:
        return {
            "message": f"服务器错误: {str(e)}",
            "code": 1
        }


@router.put("/{template_data_id}")
async def update_template_data(
    template_data_id: int,
    data_in: TemplateDataUpdate,
    db: AsyncSession = Depends(get_db),
    current_doctor: Doctor = Depends(get_current_active_doctor),
):
    """
    更新模板数据
    可更新字段：form_data（表单数据）、status（状态）
    
    流程：
    1. 验证模板数据是否存在
    2. 验证权限（只能修改自己创建的模板数据）
    3. 更新数据
    """
    try:
        # 1. 查询模板数据是否存在
        template_data = await crud_template_data.get(db, id=template_data_id)
        
        if not template_data:
            return {
                "message": "模板数据不存在",
                "code": 1
            }
        
        # 2. 验证权限：只能修改自己创建的模板数据
        if template_data.doctor_id != current_doctor.id:
            return {
                "message": "无权限修改此模板数据",
                "code": 1
            }
        
        # 3. 更新数据
        updated_template_data = await crud_template_data.update(
            db,
            db_obj=template_data,
            obj_in=data_in
        )
        
        await db.commit()
        await db.refresh(updated_template_data)
        
        # 4. 返回结果
        response_data = TemplateDataResponse.model_validate(updated_template_data)
        
        return {
            "message": "更新模板数据成功",
            "data": response_data.to_flask_format(),
            "code": 0
        }
        
    except Exception as e:
        await db.rollback()
        return {
            "message": f"服务器错误: {str(e)}",
            "code": 1
        }


# ============================================
# 患者端接口（无需JWT认证）
# ============================================

@router.get("/wx-patient/{patient_id}")
async def get_patient_template_data(
    patient_id: int,
    db: AsyncSession = Depends(get_db),
):
    """
    患者端获取自己的量表数据列表（无需JWT认证）
    仅返回 status=1（已完成）的量表
    供微信小程序患者端使用
    """
    try:
        # 验证患者是否存在
        patient = await crud_patient.get(db, id=patient_id)
        if not patient or patient.status != 1:
            return {
                "message": "患者不存在",
                "code": 1
            }
        
        # 查询该患者的所有量表数据（仅 status=1）
        template_data_list = await crud_template_data.get_by_patient(
            db,
            patient_id=patient_id,
            status=1  # 只返回已完成的量表
        )
        
        # 序列化结果
        result_data = [
            TemplateDataResponse.model_validate(td).to_flask_format()
            for td in template_data_list
        ]
        
        return {
            "message": "查询成功",
            "data": result_data,
            "code": 0
        }
        
    except Exception as e:
        return {
            "message": f"服务器错误: {str(e)}",
            "code": 1
        }


@router.get("/wx-detail/{template_data_id}")
async def get_patient_template_detail(
    template_data_id: int,
    patient_id: int,
    db: AsyncSession = Depends(get_db),
):
    """
    患者端获取量表详情（无需JWT认证）
    需要验证该量表属于该患者，且 status=1
    返回：模板结构 + 填写数据
    """
    try:
        # 1. 查询模板数据
        template_data = await crud_template_data.get(db, id=template_data_id)
        
        if not template_data:
            return {
                "message": "量表数据不存在",
                "code": 1
            }
        
        # 2. 验证权限：该量表必须属于该患者
        if template_data.patient_id != patient_id:
            return {
                "message": "您无权查看此量表",
                "code": 1
            }
        
        # 3. 验证状态：只能查看已完成的量表（status=1）
        if template_data.status != 1:
            return {
                "message": "该量表尚未完成",
                "code": 1
            }
        
        # 4. 查询对应的模板信息
        template = await crud_template.get(db, id=template_data.template_id)
        template_detail = None
        
        if template:
            # 获取模板版本历史
            version_history = template.version_history
            current_version = template_data.template_version
            target_structure = None
            
            if isinstance(version_history, list):
                for v in version_history:
                    if isinstance(v, dict) and v.get('version') == current_version:
                        target_structure = v
                        break
            elif isinstance(version_history, dict):
                target_structure = version_history.get(str(current_version))
            
            template_detail = target_structure if target_structure else version_history

        # 5. 构造响应
        response_data = TemplateDataWithDetailResponse.model_validate(template_data)
        response_data.template_detail = template_detail
        
        return {
            "message": "查询成功",
            "data": response_data.to_flask_format_with_detail(),
            "code": 0
        }
        
    except Exception as e:
        return {
            "message": f"服务器错误: {str(e)}",
            "code": 1
        }

